package com.texaco.chapasFutbol;

import java.util.HashMap;
import java.util.Map;

import org.andengine.engine.camera.Camera;
import org.andengine.engine.options.EngineOptions;
import org.andengine.engine.options.ScreenOrientation;
import org.andengine.engine.options.resolutionpolicy.RatioResolutionPolicy;
import org.andengine.entity.scene.IOnSceneTouchListener;
import org.andengine.entity.scene.Scene;
import org.andengine.entity.text.Text;
import org.andengine.entity.util.FPSLogger;
import org.andengine.input.touch.TouchEvent;
import org.andengine.opengl.font.Font;
import org.andengine.opengl.font.FontFactory;
import org.andengine.opengl.texture.TextureOptions;
import org.andengine.opengl.texture.atlas.bitmap.BitmapTextureAtlas;
import org.andengine.opengl.texture.atlas.bitmap.BitmapTextureAtlasTextureRegionFactory;
import org.andengine.opengl.texture.region.ITextureRegion;
import org.andengine.ui.activity.SimpleBaseGameActivity;
import org.andengine.util.debug.Debug;

import android.graphics.Color;
import android.opengl.GLES20;
import android.widget.Toast;

import com.texaco.chapasFutbol.entidades.Campo;
import com.texaco.chapasFutbol.entidades.Chapa;
import com.texaco.chapasFutbol.entidades.ChapaLocal;
import com.texaco.chapasFutbol.entidades.ChapaVisitante;
import com.texaco.chapasFutbol.entidades.Game;
import com.texaco.chapasFutbol.entidades.Pelota;

/*
 * Se elimina con la intención de utilizar el tablero de issues de google-code
 */
public class ChapasFutbolActivity extends SimpleBaseGameActivity implements
// IOnAreaTouchListener,
		IOnSceneTouchListener {

	/*
	 * Dimensiones de la cámara.
	 */
	private static final float CAMERA_WIDTH = 1280;
	private static final float CAMERA_HEIGHT = 800;
	private static final String CAMPO_SHAPE = "CAMPO_SHAPE";
	private static final String CHAPA_LOCAL_SHAPE = "CHAPA_LOCAL_SHAPE";
	private static final String CHAPA_VISITANTE_SHAPE = "CHAPA_VISITANTE_SHAPE";
	private static final String BALON_SHAPE = "BALON_SHAPE";

	private Font mFont;
	private Camera mCamera;
	private BitmapTextureAtlas mBackGroundTextureAtlas;
	private BitmapTextureAtlas mSpritesTextureAtlas;
	private Scene scene;
	private Text mScoreText;
	private Map<String, ITextureRegion> shapesMaps = new HashMap<String, ITextureRegion>();

	private Game game;
	Toast mensajeGol = null;
	public EngineOptions onCreateEngineOptions() {
		mensajeGol = Toast.makeText(this, "Gooool. Toca la pantallara para continuar.", Toast.LENGTH_LONG);
		this.mCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);

		final EngineOptions engineOptions = new EngineOptions(true,
				ScreenOrientation.LANDSCAPE_FIXED, new RatioResolutionPolicy(
						CAMERA_WIDTH, CAMERA_HEIGHT), this.mCamera);

		/*
		 * En estes punto tendríamos que definir si requerimos multitouch o no.
		 * Actualmente no se va a implementar multitouch pero será necesario
		 * cuando queramos hacer zoom mediante la técnica del pellizco.
		 */
		return engineOptions;
	}

	/**
	 * Método donde cargamos los recursos
	 */
	@Override
	protected void onCreateResources() {
		
		/* Cargamos la fuente de texto que usaremos para el marcador. */
		FontFactory.setAssetBasePath("font/");
		this.mFont = FontFactory.createFromAsset(this.getFontManager(), this.getTextureManager(), 512, 512, TextureOptions.BILINEAR, this.getAssets(), "Plok.ttf", 52, true, Color.BLACK);
		this.mFont.load();
		
		BitmapTextureAtlasTextureRegionFactory.setAssetBasePath("gfx/");

		/*
		 * He experimentado ciertos problemas, Por ejemplo, poniendo el tamaño
		 * del atlas (int) CAMERA_WIDTH + 1000, (int) CAMERA_HEIGHT + 1000 La
		 * pantalla se pone todo en negro. Desconozco cuales son los límites
		 * pero desde luego esta no es la forma de cargar los recursos A ver si
		 * el NONO sepone las pilas y empezamos a usar los spritesheet.
		 */
		this.mBackGroundTextureAtlas = new BitmapTextureAtlas(
				this.getTextureManager(), Campo.WIDTH, Campo.HEIGHT,
				TextureOptions.BILINEAR);
		// FIXME:
		// this.mBackGroundTextureAtlas = new BitmapTextureAtlas(
		// this.getTextureManager(), (int) 1280+ 700,
		// (int) 800 + 700, TextureOptions.BILINEAR);
		/*
		 * Atlas donde vamos a meter la imagenes correspondientes a los sprites.
		 */
		this.mSpritesTextureAtlas = new BitmapTextureAtlas(
				this.getTextureManager(), (int) CAMERA_WIDTH,
				(int) CAMERA_HEIGHT, TextureOptions.BILINEAR);

		/**
		 * Creamos los objetos que vamos a meter en el atlas del background.
		 */
		shapesMaps.put(CAMPO_SHAPE, BitmapTextureAtlasTextureRegionFactory
				.createFromAsset(this.mBackGroundTextureAtlas, this,
						Campo.IMAGEN, 0, 0));

		/**
		 * Creamos los objetos que van a ir dentro del atlas de los sprites
		 */
		shapesMaps.put(CHAPA_LOCAL_SHAPE,
				BitmapTextureAtlasTextureRegionFactory.createFromAsset(
						this.mSpritesTextureAtlas, this, ChapaLocal.IMAGEN, 0,
						0));
		shapesMaps.put(CHAPA_VISITANTE_SHAPE,
				BitmapTextureAtlasTextureRegionFactory.createFromAsset(
						this.mSpritesTextureAtlas, this, ChapaVisitante.IMAGEN,
						Chapa.WIDTH * 2, 0));
		shapesMaps.put(BALON_SHAPE, BitmapTextureAtlasTextureRegionFactory
				.createFromAsset(this.mSpritesTextureAtlas, this,
						Pelota.IMAGEN, Chapa.WIDTH * 3, 0));

		this.mBackGroundTextureAtlas.load();
		this.mSpritesTextureAtlas.load();

		/*
		 * Esta no es la forma correcta de cargar los recursos gráficos.
		 * 
		 * La forma correcta es tener un spritesheet, donde tener todos los
		 * recursos gráficos, o al menos en nuestro caso tener dos. Uno para el
		 * campo y otro para las chapas, pelota, y demás objetos que podamos
		 * tener.
		 * 
		 * La forma de hacer esto la describo acontinuación y la dejo comentada
		 * para cuando tengamos los recursos en un spritesheet o tilesheet
		 * 
		 * El ejemplo sale del MultiTouchExample.java
		 */
		// BitmapTextureAtlasTextureRegionFactory.setAssetBasePath("gfx/");
		//
		// this.mCardDeckTexture = new BitmapTextureAtlas(
		// this.getTextureManager(), 1024, 512, TextureOptions.BILINEAR);
		// BitmapTextureAtlasTextureRegionFactory.createFromAsset(
		// this.mCardDeckTexture, this, "carddeck_tiled.png", 0, 0);
		// this.mCardDeckTexture.load();
		//
		// this.mCardTotextureRegionMap = new HashMap<Card, ITextureRegion>();
		//
		// /* Extract the TextureRegion of each card in the whole deck. */
		// for (final Card card : Card.values()) {
		// final ITextureRegion cardTextureRegion = TextureRegionFactory
		// .extractFromTexture(this.mCardDeckTexture,
		// card.getTexturePositionX(),
		// card.getTexturePositionY(), Card.CARD_WIDTH,
		// Card.CARD_HEIGHT);
		// this.mCardTotextureRegionMap.put(card, cardTextureRegion);
		// }

	}

	@Override
	protected Scene onCreateScene() {
		/*
		 * Creamos el juego
		 */
		scene = new Scene();
		game = new Game(this);
		this.mEngine.registerUpdateHandler(new FPSLogger());
		
		this.mScoreText = new Text(5, 5, this.mFont, "L0 - V0", "Locales: XXXX - Visitantes: YYYY".length(), this.getVertexBufferObjectManager());
		this.mScoreText.setBlendFunction(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);
		this.mScoreText.setAlpha(0.9f);
		this.scene.attachChild(this.mScoreText);
		
		scene.registerUpdateHandler(game.getPhysicsWorld());
		scene.registerUpdateHandler(game);
		scene.setOnSceneTouchListener(this);
		return scene;
	}

	/**
	 * Evento en el que se toca una chapa. Requiere comprobar si la chapa es de
	 * tu equipo. si es tu turno si estamos pulsando y arrastrando En el evento
	 * de soltar deberá llamar al método de la chapa correspondiente para
	 * "disparar". TODO: Es posible que este no sea el evento de pulsar y
	 * arrastrar. Requiere comprobarlo.
	 */
	// public boolean onAreaTouched(TouchEvent pSceneTouchEvent,
	// ITouchArea pTouchArea, float pTouchAreaLocalX,
	// float pTouchAreaLocalY) {
	// Debug.d("Se ha detectado que se ha tocado una chapa");
	// if (pSceneTouchEvent.isActionMove()) {
	// Debug.d("Evento de movimiento");
	// }
	// return false;
	// }

	/**
	 * Este método es opcional, Lo implementaremos en el caso de que queramos
	 * mostrar solo una parte del campo y no el campo completo ya que será
	 * necesario poder arrastrar por el campo para ver el campo completo o para
	 * hacer zoom.
	 */
	public boolean onSceneTouchEvent(Scene pScene, TouchEvent pSceneTouchEvent) {
		if (game.isJuegoActivo()) {
			if (game.isArrastrandoChapa()) {
				if (pSceneTouchEvent.isActionMove()) {
					Debug.d("moviendo en la escena");
					/*
					 * Estos dos eventos deben de unificarse en mover tirador.
					 */
					game.mueveChapaFantasma(pSceneTouchEvent);
					game.actualizaVectorResultante(pSceneTouchEvent);
				} else if (pSceneTouchEvent.isActionUp()) {
					Debug.d("soltadon en la escena");
					// borraChapaFantasma();
					game.chapaSoltada();
					game.moverChapa(pSceneTouchEvent);
				}
				return true;
			}
		} else if(game.isJuegoParado()){
			// Juego inactivo.
			game.reanudarJuego();
		} else if(game.isJuegoFinalizado()){
			game.reiniciarJuego();
		}
		return true;
	}

	public Game getGame() {
		return game;
	}

	public Map<String, ITextureRegion> getShapesMaps() {
		return shapesMaps;
	}

	public Scene getScene() {
		return this.scene;
	}

	public void showMensajeGol() {
		mensajeGol.show();
	}
	
	public void actualizaMarcador() {
		this.mScoreText.setText("L"+game.marcadorLocal+" - V"+game.marcadorVisitante);
	}
}